/* ======================================================================== */
/*                                                                          */
/*  TEXAS INSTRUMENTS, INC.                                                 */
/*                                                                          */
/*  NAME                                                                    */
/*      scale_horz                                                          */
/*                                                                          */
/*                                                                          */
/*  USAGE                                                                   */
/*      This routine is C-callable and can be called as:                    */
/*                                                                          */
/*          void scale_horz                                                 */
/*          (                                                               */
/*              unsigned short *in_data,  // Ptr to unscaled lines      //  */
/*              unsigned int    in_len,   // Pixels/line unscaled       //  */
/*              short          *out_data, // Ptr to scaled data lines   //  */
/*              unsigned int    out_len,  // Pixels/line of scaled data //  */
/*              short          *hh,       // Ptr to filter taps,            */
/*                                           interleaved odd/even           */
/*                                           outputs                    //  */
/*              unsigned int    l_hh,     // Length of scaling filters  //  */
/*              unsigned int    n_hh,     // Number of scaling filters  //  */
/*              short          *patch     // Ptr to decrement pattern   //  */
/*          );                                                              */
/*                                                                          */
/*  DESCRIPTION                                                             */
/*                                                                          */
/*      This code can scale up or down 1 line of data, in the               */
/*      ratio out_len : in_len.  e.g 1 to 3, 4:3, 5:6. The                  */
/*      filters are designed outside of the loop using a                    */
/*      general purpose resizing algorithm.                                 */
/*                                                                          */
/*          patch0 = patch + 2;                                             */
/*          filter_count = n_hh;                                            */
/*          ka = 0;                                                         */
/*                                                                          */
/*          line0_x = plane_x;                                              */
/*          line0_y = plane_y;                                              */
/*          ptr_hh = hh;                                                    */
/*          jump = (int) patch[0]; ka = jump >> 1;                          */
/*          jump = (int) patch[1]; kb = jump >> 1;                          */
/*                                                                          */
/*          for ( i = 0; i < n_y; i += 2)                                   */
/*          {                                                               */
/*              y0 = 1 << 5;                                                */
/*              y1 = 1 << 5;                                                */
/*              for ( j = 0; j < l_hh; j+=4)                                */
/*              {                                                           */
/*                  // even outputs //                                      */
/*                  for (k=0; k < 4; k++)                                   */
/*                  {                                                       */
/*                      h0 = *ptr_hh++;                                     */
/*                      x0 = *(line0_x+ ka + k);                            */
/*                      y0 += ( x0 * h0 );                                  */
/*                  }                                                       */
/*                  jump = (int) (*patch0++);                               */
/*                  ka = ka + (jump>>1);                                    */
/*                  // odd outputs //                                       */
/*                  for (k=0; k < 4; k++)                                   */
/*                  {                                                       */
/*                      h1 = *ptr_hh++;                                     */
/*                      x1 = *(line0_x + kb + k);                           */
/*                      y1 += ( x1 * h1 );                                  */
/*                  }                                                       */
/*                  jump = (int) (*patch0++);                               */
/*                  kb = kb + (jump>>1);                                    */
/*              }                                                           */
/*              *line0_y++ = (short) (y0 >> 6) ;                            */
/*              *line0_y++ = (short) (y1 >> 6) ;                            */
/*                                                                          */
/*              filter_count -= 2;                                          */
/*              if (!filter_count)                                          */
/*              {                                                           */
/*                  patch0 = patch + 2;                                     */
/*                  ptr_hh = hh;                                            */
/*                  filter_count = n_hh;                                    */
/*              }                                                           */
/*          }                                                               */
/*                                                                          */
/*  ASSUMPTIONS                                                             */
/*      One line of data is produced per function call.                     */
/*                                                                          */
/*      The line must be aligned on a double word boundary and be a         */
/*      multiples of 8 bytes.                                               */
/*                                                                          */
/*      Filters are multiples of 4 taps, maximum number of filters is 256.  */
/*                                                                          */
/*      The computations for each output are interleaved, thus the filters  */
/*      are interleaved on a 4 short interval.                              */
/*                                                                          */
/*      Little ENDIAN Configuration is used and the input and output data   */
/*      is 16 bit unsinged and signed shorts respectively.  The filters     */
/*      are also 16 bit signed shorts in 12 bit precision.                  */
/*                                                                          */
/*      The n_hh filters are all of the same length and are                 */
/*      strung together in a single linear array.                           */
/*                                                                          */
/*      Interrupts are masked by the function for most of its duration.     */
/*                                                                          */
/*  MEMORY NOTE                                                             */
/*      Some bank hits will occur in this code for certain scale            */
/*      factors and filter lengths.                                         */
/*                                                                          */
/*      For 4 taps k = 0, for l_hh 8, k = 0.031, for l_hh = 16, k = 0.015.  */
/*      Different flter lengths can produce different numbers of bank       */
/*      conflicts.  Overall, these bank conflicts have nearly zero effect.  */
/*                                                                          */
/*      For l_hh=4: k=0, l_hh=8: k=1/32, l_hh=12: k=0, l_hh=16: k=1/64      */
/*      For l_hh % 8 == 0, k = 1/(4*l_hh) else k = 0                        */
/*                                                                          */
/*      'k' is the bank conflict between the store and the guidance table   */
/*      load.  Depending on the relative sizes of the filters and           */
/*      memory width, this bank conflict is between 0 and 3.1%              */
/*      overhead.                                                           */
/*                                                                          */
/*  TECHNIQUES                                                              */
/*      The outputs are computed using interleaved inputs. The patch table  */
/*      controls the access of 2 parallel pointers. For example an 8/33     */
/*      scale factor will have the following access pattern.                */
/*                                                                          */
/*                11111111112222222222333333333344444444445555555555        */
/*      012345678901234567890123456789012345678901234567890123456789        */
/*                                                                          */
/*      0  e xxxxxxxx     <-start point of even output 0                    */
/*      1      o xxxxxxxx      <-start point of odd output 4                */
/*      2          e xxxxxxxx                                               */
/*      3              o xxxxxxxx                                           */
/*      4                  e xxxxxxxx                                       */
/*      5                      o xxxxxxxx                                   */
/*      6                          e xxxxxxxx                               */
/*      7                              o xxxxxxxx                           */
/*      0                                   e xxxxxxxx  <-next start        */
/*      1                                       o xxxxxxxx  <-next start    */
/*                                                                          */
/*                                                                          */
/*      From this diagram the odd pointer jumps 4 then another 4 as the     */
/*      filters have 8 taps, it then jumps 4 to get to the next set of      */
/*      input data. The odd pointer does the same. These jumps are          */
/*      interleaved and so are the filter coefficients. The jumps are       */
/*      in multiples of bytes as non-scaled non-aligned double word         */
/*      accesses are used.  In this case the table will be:                 */
/*                                                                          */
/*          short patch[] = {0,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,10,10,8,8};    */
/*                                                                          */
/*      Notice the first 2 entries are the intial starting points for       */
/*      the two pointers. To remove a dependency in the code the last 2     */
/*      entries are copies of the 2nd two. This makes the table almost      */
/*      circular.                                                           */
/*                                                                          */
/*  NOTES                                                                   */
/*      Other scale factors can be achieved with the following              */
/*      example tables.                                                     */
/*                                                                          */
/*  Scale Factor Taps  Table short jump[] =                                 */
/*  --------------------------------------------------------------------    */
/*      5/6       4    {0, 1, 2, 2, 2, 3, 3, 2, 2, 2, 3, 3, 2, 2}           */
/*      4/3       8    {0, 4, 4, 4, -3, -2, 4, 4, -2, -3, 4, 4}             */
/*      3/4       12   {0,1,4,4,4,4,-6,-5,4,4,4,4,-5,-6,4,4,4,4,-5,-5,4,4}  */
/*      6/5       16   {0,0,4,4,4,4,4,4,-11,-10,4,4,4,4,4,4,-10,-10,        */
/*                      4,4,4,4,4,4,-10,-11,4,4}                            */
/*                                                                          */
/*      The software to produce these tables and the simple coefficents     */
/*      for an arbitarary scale factor and number of taps can be found      */
/*      in the api document. Note in the case of 3/4, odd scale factors     */
/*      are doubled to make 6/8 instead of 3/4                              */
/*                                                                          */
/*  CYCLES                                                                  */
/*      cycles = 0.5 * out_len * l_hh * (1+k) + 30.                         */
/*      If (l_hh % 8) == 0 then k = 1/(4*l_hh) else k = 0.                  */
/*                                                                          */
/*      For l_hh = 16, in_len = 1024, and out_len = 1366,  cycles = 11129.  */
/*      For l_hh = 8,  in_len = 640,  and out_len = 120,   cycles = 525.    */
/*                                                                          */
/*  CODESIZE                                                                */
/*      296 bytes                                                           */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2000 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
void scale_horz_asm
(
    short *in_data,  /* Ptr to unscaled lines      */
    unsigned int    in_len,   /* Pixels/line unscaled       */
    short          *out_data, /* Ptr to scaled data lines   */
    unsigned int    out_len,  /* Pixels/line of scaled data */
    short          *hh,       /* Ptr to filter taps,
                                 interleaved odd/even
                                 outputs                    */
    unsigned int    l_hh,     /* Length of scaling filters  */
    unsigned int    n_hh,     /* Number of scaling filters  */
    short          *patch,     /* Ptr to decrement pattern   */
    short          *filt_state
);
/* ======================================================================== */
/*  End of file:  scale_horz_h.h                                            */
/* ------------------------------------------------------------------------ */
/*            Copyright (c) 2000 Texas Instruments, Incorporated.           */
/*                           All Rights Reserved.                           */
/* ======================================================================== */
